home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / timedat.exe / TIMESPAN.CPP < prev    next >
C/C++ Source or Header  |  1992-05-06  |  6KB  |  321 lines
  1.  
  2. /*
  3.  Copyright 1992 - John K. Humkey
  4.  */
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <conio.h>
  9. #include <string.h>
  10. #include <dos.h>
  11. #include "timespan.h"
  12.  
  13. void astro_to_date(int *year, int *month, int *day, long *ast);
  14. void date_to_astro(int *year, int *month, int *day, long *ast);
  15. void time_to_astro(int *hour, int *mins,  int *sec, int *millisec, long *ast);
  16. void astro_to_time(int *hour, int *mins,  int *sec, int *millisec, long *ast);
  17.  
  18. //
  19. // TIMESPAN::OPERATOR +
  20. //
  21. //
  22. timespan operator + ( timespan &tdone, timespan &tdtwo )
  23. {
  24. timespan temptd;
  25. long dx,tx;
  26.  
  27.     tx = tdone.msecval + tdtwo.msecval;
  28.     dx = tdone.daysval + tdtwo.daysval;
  29.     dx += tx / (24L * 60L * 60L * 1000L);
  30.     tx %= (24L * 60L * 60L * 1000L);
  31.     temptd.setdt(dx,tx);
  32.  
  33.     return temptd;
  34. }
  35.  
  36. //
  37. // TIMESPAN::OPERATOR -
  38. //
  39. //
  40. timespan operator - ( timespan &tdone, timespan &tdtwo )
  41. {
  42. timespan temptd,tanother;
  43. long dx,tx;
  44.  
  45.     if ( (tdone.daysval < tdtwo.daysval) ||
  46.      ((tdone.daysval == tdtwo.daysval) && (tdone.msecval < tdtwo.msecval))) {
  47.         temptd.setdt(0L,0L);
  48.     }
  49.     else {
  50.         if (tdone.msecval < tdtwo.msecval) {
  51.             tanother.daysval = tdone.daysval - 1;
  52.             tanother.msecval = tdone.msecval + (24L * 60L * 60L * 1000);
  53.         }
  54.         else {
  55.             tanother = tdone;
  56.         }
  57.         tx = tanother.msecval - tdtwo.msecval;
  58.         dx = tanother.daysval - tdtwo.daysval;
  59.         dx += tx / (24L * 60L * 60L * 1000L);
  60.         tx %= (24L * 60L * 60L * 1000L);
  61.         temptd.setdt(dx,tx);
  62.     }
  63.  
  64.     return temptd;
  65. }
  66.  
  67. //
  68. // TIMESPAN::OPERATOR *
  69. //
  70. //
  71. timespan operator * ( timespan &tdone, int multval )
  72. {
  73. timespan temptd;
  74. long dx,tx;
  75.  
  76.     tx = tdone.msecval * (long)multval;
  77.     dx = tdone.daysval * (long)multval;
  78.     dx += tx / (24L * 60L * 60L * 1000L);
  79.     tx %= (24L * 60L * 60L * 1000L);
  80.     temptd.setdt(dx,tx);
  81.  
  82.     return temptd;
  83. }
  84.  
  85. //
  86. // TIMESPAN::OPERATOR /
  87. //
  88. //
  89. timespan operator / ( timespan &tdone, int divideval )
  90. {
  91. timespan temptd;
  92. long dx,tx;
  93.  
  94.     if (divideval==0) return tdone;
  95.  
  96.     tx = tdone.msecval / (long)divideval;
  97.     dx = tdone.daysval / (long)divideval;
  98.     tx += (tdone.daysval % (long)divideval) * (24L * 60L * 60L * 1000L);
  99.     dx += tx / (24L * 60L * 60L * 1000L);
  100.     tx %= (24L * 60L * 60L * 1000L);
  101.     temptd.setdt(dx,tx);
  102.  
  103.     return temptd;
  104. }
  105.  
  106. //
  107. // TIMESPAN::OPERATOR +=
  108. //
  109. //
  110. timespan operator += ( timespan &tdone, timespan &tdtwo )
  111. {
  112. timespan temptd;
  113. long dx,tx;
  114.  
  115.     tx = tdone.msecval + tdtwo.msecval;
  116.     dx = tdone.daysval + tdtwo.daysval;
  117.     dx += tx / (24L * 60L * 60L * 1000L);
  118.     tx %= (24L * 60L * 60L * 1000L);
  119.     tdone.setdt(dx,tx);
  120.  
  121.     return tdone;
  122. }
  123.  
  124. //
  125. // TIMESPAN::OPERATOR -=
  126. //
  127. //
  128. timespan operator -= ( timespan &tdone, timespan &tdtwo )
  129. {
  130. timespan temptd,tanother;
  131. long dx,tx;
  132.  
  133.     if ( (tdone.daysval < tdtwo.daysval) ||
  134.      ((tdone.daysval == tdtwo.daysval) && (tdone.msecval < tdtwo.msecval))) {
  135.         tdone.setdt(0L,0L);
  136.     }
  137.     else {
  138.         if (tdone.msecval < tdtwo.msecval) {
  139.             tanother.daysval = tdone.daysval - 1;
  140.             tanother.msecval = tdone.msecval + (24L * 60L * 60L * 1000);
  141.         }
  142.         else {
  143.             tanother = tdone;
  144.         }
  145.         tx = tanother.msecval - tdtwo.msecval;
  146.         dx = tanother.daysval - tdtwo.daysval;
  147.         dx += tx / (24L * 60L * 60L * 1000L);
  148.         tx %= (24L * 60L * 60L * 1000L);
  149.         tdone.setdt(dx,tx);
  150.     }
  151.  
  152.     return tdone;
  153. }
  154.  
  155. //
  156. // TIMESPAN::OPERATOR *=
  157. //
  158. //
  159. timespan operator *= ( timespan &tdone, int multval )
  160. {
  161. timespan temptd;
  162. long dx,tx;
  163.  
  164.     tx = tdone.msecval * (long)multval;
  165.     dx = tdone.daysval * (long)multval;
  166.     dx += tx / (24L * 60L * 60L * 1000L);
  167.     tx %= (24L * 60L * 60L * 1000L);
  168.     tdone.setdt(dx,tx);
  169.  
  170.     return tdone;
  171. }
  172.  
  173. //
  174. // TIMESPAN::OPERATOR /=
  175. //
  176. //
  177. timespan operator /= ( timespan &tdone, int divideval )
  178. {
  179. timespan temptd;
  180. long dx,tx;
  181.  
  182.     if (divideval==0) return tdone;
  183.  
  184.     tx = tdone.msecval / (long)divideval;
  185.     dx = tdone.daysval / (long)divideval;
  186.     tx += (tdone.daysval % (long)divideval) * (24L * 60L * 60L * 1000L);
  187.     dx += tx / (24L * 60L * 60L * 1000L);
  188.     tx %= (24L * 60L * 60L * 1000L);
  189.     tdone.setdt(dx,tx);
  190.  
  191.     return tdone;
  192. }
  193.  
  194. //
  195. // TIMESPAN::OPERATOR <
  196. //
  197. //
  198. int      operator < ( timespan &tdone, timespan &tdtwo )
  199. {
  200.     if ( (tdone.daysval < tdtwo.daysval) ||
  201.           ((tdone.daysval == tdtwo.daysval) && (tdone.msecval < tdtwo.msecval)))
  202.         return 1;
  203.     else
  204.         return 0;
  205. }
  206.  
  207. //
  208. // TIMESPAN::OPERATOR >
  209. //
  210. //
  211. int      operator > ( timespan &tdone, timespan &tdtwo )
  212. {
  213.     if ( (tdone.daysval > tdtwo.daysval) ||
  214.           ((tdone.daysval == tdtwo.daysval) && (tdone.msecval > tdtwo.msecval)))
  215.         return 1;
  216.     else
  217.         return 0;
  218. }
  219.  
  220. //
  221. // TIMESPAN::OPERATOR ==
  222. //
  223. //
  224. int      operator == ( timespan &tdone, timespan &tdtwo )
  225. {
  226.     if ( (tdone.daysval == tdtwo.daysval) &&
  227.           (tdone.msecval == tdtwo.msecval) )
  228.         return 1;
  229.     else
  230.         return 0;
  231. }
  232.  
  233. //
  234. // TIMESPAN::OPERATOR !=
  235. //
  236. //
  237. int      operator != ( timespan &tdone, timespan &tdtwo )
  238. {
  239.     if ( (tdone.daysval != tdtwo.daysval) ||
  240.           (tdone.msecval != tdtwo.msecval) )
  241.         return 1;
  242.     else
  243.         return 0;
  244. }
  245.  
  246. //
  247. // TIMESPAN::OPERATOR <=
  248. //
  249. //
  250. int      operator <= ( timespan &tdone, timespan &tdtwo )
  251. {
  252.   if (((tdone.daysval == tdtwo.daysval) &&
  253.           (tdone.msecval == tdtwo.msecval) ) ||
  254.         ((tdone.daysval < tdtwo.daysval) ||
  255.          ((tdone.daysval == tdtwo.daysval) && (tdone.msecval < tdtwo.msecval))))
  256.         return 1;
  257.     else
  258.         return 0;
  259. }
  260.  
  261. //
  262. // TIMESPAN::OPERATOR >=
  263. //
  264. //
  265. int      operator >= ( timespan &tdone, timespan &tdtwo )
  266. {
  267.   if (((tdone.daysval == tdtwo.daysval) &&
  268.          (tdone.msecval == tdtwo.msecval) ) ||
  269.         ((tdone.daysval > tdtwo.daysval) ||
  270.          ((tdone.daysval == tdtwo.daysval) && (tdone.msecval > tdtwo.msecval))))
  271.         return 1;
  272.     else
  273.         return 0;
  274. }
  275.  
  276. //
  277. // TIMESPAN::TIMESPAN
  278. //
  279. //
  280. timespan::timespan(long numdays,
  281.                          int hour, int minute, int second, int millisecond)
  282. {
  283.     daysval = numdays;
  284.     time_to_astro(&hour,&minute,&second,&millisecond,&msecval);
  285. }
  286.  
  287. //
  288. // TIMESPAN::~TIMESPAN
  289. //
  290. // Destructor, waits for keypress on screen, closes files for other modes.
  291. //
  292. timespan::~timespan()
  293. {
  294. }
  295.  
  296. //
  297. // TIMESPAN::PRINT
  298. //
  299. // Prints internal values of a timespan variable.
  300. //
  301. void timespan::print()
  302. {
  303. int year, month, day, hour, mins, sec, millisec;
  304.  
  305.     astro_to_time(&hour,&mins,&sec,&millisec,&msecval);
  306.     printf("%08ld %02d:%02d:%02d.%d\n", daysval,hour,mins,sec,millisec);
  307. }
  308.  
  309. //
  310. // TIMESPAN::SETDT
  311. //
  312. // Sets internal values of a timespan variable.
  313. //
  314. void timespan::setdt(long dx, long tx)
  315. {
  316.     daysval = dx;
  317.     msecval = tx;
  318. }
  319.  
  320.  
  321.